using System;
using System.Collections.Generic;
using WenYu.Core.Lexer;
using WenYu.Core.Errors;

namespace WenYu.Core.Parser;

/// <summary>
/// 文语语法分析器 - 递归下降解析器
/// </summary>
public class WenYuParser
{
    private readonly List<Token> _tokens;
    private int _current = 0;
    private readonly List<string> _errors = new List<string>();
    private readonly bool _throwOnError;
    private readonly string _sourceCode;
    private readonly string _filePath;
    private readonly IErrorFormatter _errorFormatter;
    
    public WenYuParser(List<Token> tokens, bool throwOnError = false, string sourceCode = "", string filePath = "")
    {
        _tokens = tokens;
        _throwOnError = throwOnError;
        _sourceCode = sourceCode;
        _filePath = filePath;
        _errorFormatter = new ConsoleErrorFormatter();
    }
    
    public WenYuParser(string source, bool throwOnError = false, string filePath = "")
    {
        var lexer = new WenYuLexer(source);
        _tokens = lexer.Tokenize();
        _throwOnError = throwOnError;
        _sourceCode = source;
        _filePath = filePath;
        _errorFormatter = new ConsoleErrorFormatter();
    }
    
    /// <summary>
    /// 解析整个程序
    /// </summary>
    public Program Parse()
    {
        var program = new Program();
        
        while (!IsAtEnd())
        {
            int positionBeforeStatement = _current;  // 记录解析前的位置
            
            try
            {
                var statement = ParseStatement();
                if (statement != null)
                {
                    program.Statements.Add(statement);
                }
            }
            catch (ParseException ex)
            {
                _errors.Add(ex.Message);
                
                // 如果要求立即抛出错误，则重新抛出
                if (_throwOnError)
                {
                    throw;
                }
                
                Synchronize(); // 错误恢复
                
                // 防止死循环：如果位置没有推进，强制前进至少一个token
                if (_current == positionBeforeStatement && !IsAtEnd())
                {
                    Advance();
                }
            }
        }
        
        // 如果有错误且要求抛出，则抛出第一个错误
        if (_throwOnError && _errors.Count > 0)
        {
            throw new ParseException(_errors[0]);
        }
        
        return program;
    }
    
    /// <summary>
    /// 获取解析错误列表
    /// </summary>
    public List<string> GetErrors() => _errors;
    
    // ==================== 辅助方法 ====================
    
    /// <summary>
    /// 检查是否到达Token流末尾
    /// </summary>
    private bool IsAtEnd() => Peek().Type == TokenType.EOF;
    
    /// <summary>
    /// 查看当前Token
    /// </summary>
    private Token Peek() => _tokens[_current];
    
    /// <summary>
    /// 查看前一个Token
    /// </summary>
    private Token Previous() => _tokens[_current - 1];
    
    /// <summary>
    /// 前进到下一个Token
    /// </summary>
    private Token Advance()
    {
        if (!IsAtEnd()) _current++;
        return Previous();
    }
    
    /// <summary>
    /// 检查当前Token类型
    /// </summary>
    private bool Check(TokenType type)
    {
        if (IsAtEnd()) return false;
        return Peek().Type == type;
    }
    
    /// <summary>
    /// 检查当前Token值
    /// </summary>
    private bool CheckValue(string value)
    {
        if (IsAtEnd()) return false;
        return Peek().Value == value;
    }
    
    /// <summary>
    /// 匹配并前进
    /// </summary>
    private bool Match(params TokenType[] types)
    {
        foreach (var type in types)
        {
            if (Check(type))
            {
                Advance();
                return true;
            }
        }
        return false;
    }
    
    /// <summary>
    /// 匹配关键字值并前进
    /// </summary>
    private bool MatchKeyword(params string[] keywords)
    {
        foreach (var keyword in keywords)
        {
            if (CheckValue(keyword))
            {
                Advance();
                return true;
            }
        }
        return false;
    }
    
    /// <summary>
    /// 匹配标点符号值并前进
    /// </summary>
    private bool MatchPunctuation(params string[] punctuations)
    {
        foreach (var punctuation in punctuations)
        {
            if (Check(TokenType.Punctuation) && Peek().Value == punctuation)
            {
                Advance();
                return true;
            }
        }
        return false;
    }
    
    /// <summary>
    /// 消费任意Token作为标识符（包括关键字），用于函数名等位置
    /// 支持多Token组合如"加法"（Identifier + Keyword "法"）
    /// </summary>
    private string ConsumeAnyAsIdentifier(string errorMessage)
    {
        if (IsAtEnd())
        {
            throw Error(Peek(), errorMessage);
        }
        
        var nameParts = new List<string>();
        
        // 连续读取Identifier和Keyword，直到遇到特定分隔符
        while (!IsAtEnd())
        {
            var token = Peek();
            
            // 可以作为名称的Token类型
            if (token.Type == TokenType.Identifier || 
                token.Type == TokenType.Keyword ||
                token.Type == TokenType.TypeKeyword)
            {
                nameParts.Add(token.Value);
                Advance();
                
                // 如果下一个Token是分隔符（如 { ），停止
                if (!IsAtEnd() && Check(TokenType.Punctuation) && Peek().Value == "{")
                {
                    break;
                }
            }
            else
            {
                break;
            }
        }
        
        if (nameParts.Count == 0)
        {
            throw Error(Peek(), errorMessage);
        }
        
        return string.Join("", nameParts);
    }
    
    /// <summary>
    /// 判断当前位置是否是函数定义（而不是变量声明）
    /// 函数定义模式：类型 名字，类型 名字... 求 ...
    /// 变量声明模式：类型 名字 是 ... 或 类型 名字。
    /// </summary>
    private bool IsFunctionDeclaration()
    {
        int lookahead = _current;
        
        // 必须以类型关键字开头
        if (lookahead >= _tokens.Count || 
            (_tokens[lookahead].Type != TokenType.TypeKeyword && 
             _tokens[lookahead].Type != TokenType.ArrayTypeKeyword))
        {
            return false;
        }
        
        // 循环检查参数模式：类型 名字 [，类型 名字...]
        while (lookahead < _tokens.Count)
        {
            // 跳过类型关键字
            if (_tokens[lookahead].Type == TokenType.TypeKeyword || 
                _tokens[lookahead].Type == TokenType.ArrayTypeKeyword)
            {
                lookahead++;
            }
            else
            {
                break;
            }
            
            // 期望参数名（标识符）
            if (lookahead < _tokens.Count && _tokens[lookahead].Type == TokenType.Identifier)
            {
                lookahead++;
            }
            else
            {
                // 没有参数名，不是函数定义
                return false;
            }
            
            // 检查下一个token
            if (lookahead >= _tokens.Count)
            {
                return false;
            }
            
            var nextToken = _tokens[lookahead];
            
            // 如果是逗号，继续解析下一个参数
            if (nextToken.Type == TokenType.Punctuation && 
                (nextToken.Value == "，" || nextToken.Value == ","))
            {
                lookahead++; // 跳过逗号
                continue; // 继续循环解析下一个参数
            }
            
            // 如果是"求"，确认是函数定义
            if (nextToken.Value == "求")
            {
                return true;
            }
            
            // 如果是"是"或"。"，是变量声明
            if (nextToken.Value == "是" || nextToken.Value == "。" || nextToken.Value == ".")
            {
                return false;
            }
            
            // 其他情况，不确定
            break;
        }
        
        return false;
    }
    
    /// <summary>
    /// 期望特定Token类型，否则报错
    /// </summary>
    private Token Consume(TokenType type, string message)
    {
        if (Check(type)) return Advance();
        
        // 检查是否是括号不匹配错误
        var token = Peek();
        if (type == TokenType.Punctuation && 
            (message.Contains("期望") || message.Contains("括号")))
        {
            // 提取期望的符号
            var expected = ExtractExpectedFromMessage(message);
            if (!string.IsNullOrEmpty(expected))
            {
                var compileError = ParserErrors.MismatchedParentheses(token, expected, _sourceCode, _filePath);
                if (_throwOnError)
                {
                    _errorFormatter.Print(compileError);
                }
                throw new ParseException(compileError);
            }
        }
        
        throw Error(Peek(), message);
    }
    
    /// <summary>
    /// 从错误消息中提取期望的符号
    /// </summary>
    private string ExtractExpectedFromMessage(string message)
    {
        // 简单实现：提取引号中的内容
        var start = message.IndexOf("'");
        if (start >= 0)
        {
            var end = message.IndexOf("'", start + 1);
            if (end > start)
            {
                return message.Substring(start + 1, end - start - 1);
            }
        }
        
        start = message.IndexOf("\"");
        if (start >= 0)
        {
            var end = message.IndexOf("\"", start + 1);
            if (end > start)
            {
                return message.Substring(start + 1, end - start - 1);
            }
        }
        
        return "";
    }
    
    /// <summary>
    /// 期望特定关键字，否则报错
    /// </summary>
    private Token ConsumeKeyword(string keyword, string message)
    {
        if (CheckValue(keyword)) return Advance();
        
        // 特殊处理常见错误
        if (keyword == "则")
        {
            var compileError = ParserErrors.MissingThen(Peek(), _sourceCode, _filePath);
            if (_throwOnError)
            {
                _errorFormatter.Print(compileError);
            }
            throw new ParseException(compileError);
        }
        
        // 其他关键字错误使用通用格式
        throw Error(Peek(), message);
    }
    
    /// <summary>
    /// 消费语句结束符（。或.）
    /// </summary>
    private Token ConsumePeriod(string message = "期望'。'或'.'结束语句")
    {
        if (Check(TokenType.Punctuation))
        {
            var token = Peek();
            if (token.Value == "。" || token.Value == ".")
            {
                return Advance();
            }
        }
        
        // 使用新的8段式错误提示
        var compileError = ParserErrors.MissingPeriod(Peek(), _sourceCode, _filePath);
        if (_throwOnError)
        {
            _errorFormatter.Print(compileError);
        }
        throw new ParseException(compileError);
    }
    
    /// <summary>
    /// 创建解析错误
    /// </summary>
    private ParseException Error(Token token, string message)
    {
        var error = $"[第{token.Line}行:{token.Column}列] 语法错误: {message}";
        return new ParseException(error);
    }
    
    /// <summary>
    /// 错误恢复 - 同步到下一个安全点
    /// </summary>
    private void Synchronize()
    {
        Advance();
        
        while (!IsAtEnd())
        {
            // 遇到句号，说明上一条语句结束
            if (Previous().Type == TokenType.Punctuation && 
                (Previous().Value == "。" || Previous().Value == "."))
            {
                return;
            }
            
            // 遇到右大括号，说明块结束
            if (Previous().Type == TokenType.Punctuation && Previous().Value == "}")
            {
                return;
            }
            
            // 遇到关键字，可能是新语句开始
            if (Peek().Type == TokenType.TypeKeyword || 
                CheckValue("若") || CheckValue("复") || CheckValue("求"))
            {
                return;
            }
            
            Advance();
        }
    }
    
    // ==================== 语句解析 ====================
    
    /// <summary>
    /// 解析语句
    /// </summary>
    private Statement? ParseStatement()
    {
        // 跳过注释
        while (Match(TokenType.Comment)) { }
        
        if (IsAtEnd()) return null;
        
        // 变量声明 or 函数定义（都以类型关键字开头）
        if (Check(TokenType.TypeKeyword) || Check(TokenType.ArrayTypeKeyword))
        {
            // 向前看，判断是函数定义还是变量声明
            // 函数定义模式：类型 名字 ， 类型 ... 或 类型 名字 求
            if (IsFunctionDeclaration())
            {
                return ParseFunctionDeclaration();
            }
            return ParseVarDeclaration();
        }
        
        // 类数组声明：类名+组（如 车组 车队）
        // 或类定义：类名 是 类（如 车 是 类）
        // 或对象创建：类名 对象名（如 车 宝马）
        if (Check(TokenType.Identifier))
        {
            // 向前看：是否紧跟"组"关键字
            if (_current + 1 < _tokens.Count && _tokens[_current + 1].Value == "组")
            {
                return ParseVarDeclaration();
            }
            
            // 向前看：是否紧跟"是 类"（类定义）
            if (_current + 2 < _tokens.Count && 
                _tokens[_current + 1].Value == "是" && 
                _tokens[_current + 2].Value == "类")
            {
                return ParseClassDeclaration();
            }
            
            // 向前看：是否是对象创建（类名 对象名）
            if (_current + 1 < _tokens.Count && 
                _tokens[_current + 1].Type == TokenType.Identifier)
            {
                return ParseObjectCreation();
            }
        }
        
        // 类型推导声明（设开头）
        if (CheckValue("设"))
        {
            return ParseAutoVarDeclaration();
        }
        
        // 条件语句（若开头）
        if (CheckValue("若"))
        {
            return ParseIfOrWhileStatement();
        }
        
        // 循环语句（复开头）
        if (CheckValue("复"))
        {
            return ParseForOrDoWhileStatement();
        }
        
        // 函数定义（求开头）
        if (CheckValue("求"))
        {
            return ParseFunctionDeclaration();
        }
        
        // 循环控制语句
        if (CheckValue("停"))
        {
            Advance();
            ConsumePeriod();
            return new BreakStatement();
        }
        
        if (CheckValue("跳"))
        {
            Advance();
            ConsumePeriod();
            return new ContinueStatement();
        }
        
        // 返回语句
        if (CheckValue("得"))
        {
            return ParseReturnStatement(true);
        }
        
        if (CheckValue("回"))
        {
            return ParseReturnStatement(false);
        }
        
        // 赋值或表达式语句
        return ParseAssignmentOrExpressionStatement();
    }
    
    /// <summary>
    /// 解析变量声明
    /// </summary>
    private Statement ParseVarDeclaration()
    {
        var typeToken = Advance(); // 类型关键字、数组类型关键字、或类名(Identifier)
        var type = typeToken.Value;
        
        // 情况1：直接是ArrayTypeKeyword（如"整型组"作为单个token）
        if (typeToken.Type == TokenType.ArrayTypeKeyword)
        {
            // 提取元素类型（去掉末尾的"组"）
            var elementType = type.EndsWith("组") ? type.Substring(0, type.Length - 1) : type;
            var name = Consume(TokenType.Identifier, "期望变量名").Value;
            
            Expression? init = null;
            Expression? length = null;
            
            // 检查初始化
            if (MatchKeyword("是"))
            {
                init = ParseExpression();
            }
            else if (MatchKeyword("，") && CheckValue("长"))
            {
                Advance(); // 跳过"长"
                length = ParseExpression();
            }
            
            ConsumePeriod();
            
            return new ArrayDeclStatement(elementType, name, init, length);
        }
        
        // 情况2：TypeKeyword或Identifier后跟"组"（如"整型" + "组"两个token或"车" + "组"）
        if (CheckValue("组"))
        {
            Advance(); // 消费"组"关键字
            var elementType = type;
            var name = Consume(TokenType.Identifier, "期望变量名").Value;
            
            Expression? init = null;
            Expression? length = null;
            
            // 检查初始化
            if (MatchKeyword("是"))
            {
                init = ParseExpression();
            }
            else if (MatchKeyword("，") && CheckValue("长"))
            {
                Advance(); // 跳过"长"
                length = ParseExpression();
            }
            
            ConsumePeriod();
            
            return new ArrayDeclStatement(elementType, name, init, length);
        }
        
        // 情况3：普通变量声明
        var varName = Consume(TokenType.Identifier, "期望变量名").Value;
        
        Expression? initValue = null;
        if (MatchKeyword("是"))
        {
            initValue = ParseExpression();
        }
        
        ConsumePeriod();
        
        return new VarDeclStatement(type, varName, initValue);
    }
    
    /// <summary>
    /// 解析类型推导声明（设）
    /// </summary>
    private Statement ParseAutoVarDeclaration()
    {
        Advance(); // 跳过"设"
        var name = Consume(TokenType.Identifier, "期望变量名").Value;
        ConsumeKeyword("是", "期望'是'");
        var init = ParseExpression();
        ConsumePeriod();
        
        return new VarDeclStatement("auto", name, init);
    }
    
    /// <summary>
    /// 解析条件或while语句（若开头）
    /// </summary>
    private Statement ParseIfOrWhileStatement()
    {
        Advance(); // 跳过"若"
        var condition = ParseExpression();
        
        // 检查是则（if）还是复（while）
        if (MatchKeyword("则"))
        {
            return ParseIfStatement(condition);
        }
        else if (MatchKeyword("复"))
        {
            return ParseWhileStatement(condition);
        }
        else
        {
            throw Error(Peek(), "期望'则'或'复'");
        }
    }
    
    /// <summary>
    /// 解析if语句
    /// </summary>
    private IfStatement ParseIfStatement(Expression condition)
    {
        var thenBlock = ParseBlock();
        BlockStatement? elseBlock = null;
        
        // 检查"又"（else if）
        if (CheckValue("又"))
        {
            Advance(); // 跳过"又"
            var elseIfCondition = ParseExpression();
            ConsumeKeyword("则", "期望'则'");
            elseBlock = new BlockStatement();
            elseBlock.Statements.Add(ParseIfStatement(elseIfCondition));
        }
        // 检查"余"（else）
        else if (MatchKeyword("余"))
        {
            elseBlock = ParseBlock();
        }
        
        return new IfStatement(condition, thenBlock, elseBlock);
    }
    
    /// <summary>
    /// 解析while语句
    /// </summary>
    private WhileStatement ParseWhileStatement(Expression condition)
    {
        var body = ParseBlock();
        return new WhileStatement(condition, body, false);
    }
    
    /// <summary>
    /// 解析for或do-while语句（复开头）
    /// </summary>
    private Statement ParseForOrDoWhileStatement()
    {
        Advance(); // 跳过"复"
        
        // 检查是否是do-while（复{...}若...续）
        if (Check(TokenType.Punctuation) && Peek().Value == "{")
        {
            return ParseDoWhileStatement();
        }
        
        // 检查是否是foreach（复 数组 取 变量）
        if (Check(TokenType.Identifier))
        {
            var lookahead = _tokens[_current + 1];
            if (lookahead.Type == TokenType.Keyword && lookahead.Value == "取")
            {
                return ParseForEachStatement();
            }
        }
        
        // 否则是for循环
        return ParseForStatement();
    }
    
    /// <summary>
    /// 解析do-while语句
    /// </summary>
    private WhileStatement ParseDoWhileStatement()
    {
        var body = ParseBlock();
        ConsumeKeyword("若", "期望'若'");
        var condition = ParseExpression();
        ConsumeKeyword("续", "期望'续'");
        Consume(TokenType.Punctuation, "期望'。'");
        
        return new WhileStatement(condition, body, true);
    }
    
    /// <summary>
    /// 解析for语句
    /// </summary>
    private ForStatement ParseForStatement()
    {
        string variable;
        Expression start, end, step;
        
        // 检查是否有自定义变量名
        if (Check(TokenType.Identifier))
        {
            // 完整形式：复 序号 从 0 至 10 步 1
            variable = Advance().Value;
            ConsumeKeyword("从", "期望'从'");
            start = ParseExpression();
        }
        else
        {
            // 简化形式：复 1 至 10
            variable = "几";
            start = ParseExpression();
        }
        
        ConsumeKeyword("至", "期望'至'");
        end = ParseExpression();
        
        // 检查是否有步长
        if (MatchKeyword("步"))
        {
            step = ParseExpression();
        }
        else
        {
            step = new IntegerLiteral(1);
        }
        
        var body = ParseBlock();
        
        return new ForStatement(variable, start, end, step, body);
    }
    
    /// <summary>
    /// 解析foreach语句
    /// </summary>
    private ForEachStatement ParseForEachStatement()
    {
        var arrayExpr = ParsePrimaryExpression();
        ConsumeKeyword("取", "期望'取'");
        var variable = Consume(TokenType.Identifier, "期望元素变量名").Value;
        var body = ParseBlock();
        
        return new ForEachStatement(arrayExpr, variable, body);
    }
    
    /// <summary>
    /// 解析语句块 {...}
    /// </summary>
    private BlockStatement ParseBlock()
    {
        Consume(TokenType.Punctuation, "期望'{'");
        if (Previous().Value != "{")
        {
            throw Error(Previous(), "期望'{'开始语句块");
        }
        
        var block = new BlockStatement();
        
        while (!Check(TokenType.Punctuation) || Peek().Value != "}")
        {
            if (IsAtEnd())
            {
                throw Error(Peek(), "未闭合的语句块，缺少'}'");
            }
            
            var statement = ParseStatement();
            if (statement != null)
            {
                block.Statements.Add(statement);
            }
        }
        
        Consume(TokenType.Punctuation, "期望'}'");
        
        return block;
    }
    
    /// <summary>
    /// 解析函数定义
    /// </summary>
    private FunctionDeclaration ParseFunctionDeclaration()
    {
        // 先解析参数列表
        var parameters = new List<Parameter>();
        
        // 检查是否有参数（类型关键字开头）
        while (Check(TokenType.TypeKeyword))
        {
            var paramType = Advance().Value;
            var paramName = Consume(TokenType.Identifier, "期望参数名").Value;
            parameters.Add(new Parameter(paramType, paramName));
            
            // 检查是否有更多参数（支持中英文逗号）
            if (MatchPunctuation("，", ","))
            {
                continue;
            }
            else
            {
                break;
            }
        }
        
        // 跳过"求"（如果还没跳过）
        if (CheckValue("求"))
        {
            Advance();
        }
        
        // 检查返回类型
        string? returnType = null;
        if (Check(TokenType.TypeKeyword))
        {
            returnType = Advance().Value;
            ConsumeKeyword("之", "期望'之'");
        }
        
        ConsumeKeyword("法", "期望'法'");
        // 使用ConsumeAnyAsIdentifier允许函数名包含关键字（如"加法"）
        var name = ConsumeAnyAsIdentifier("期望函数名");
        var body = ParseBlock();
        
        return new FunctionDeclaration(returnType, name, parameters, body);
    }
    
    /// <summary>
    /// 解析返回语句
    /// </summary>
    private ReturnStatement ParseReturnStatement(bool hasValue)
    {
        Advance(); // 跳过"得"或"回"
        
        Expression? value = null;
        if (hasValue)
        {
            value = ParseExpression();
        }
        
        ConsumePeriod();
        
        return new ReturnStatement(value, hasValue);
    }
    
    /// <summary>
    /// 解析赋值或表达式语句
    /// </summary>
    private Statement ParseAssignmentOrExpressionStatement()
    {
        var expr = ParseExpression();
        
        // 检查是否是赋值
        if (MatchKeyword("是"))
        {
            var value = ParseExpression();
            ConsumePeriod();
            return new AssignmentStatement(expr, value);
        }
        
        // 否则是表达式语句
        ConsumePeriod();
        return new ExpressionStatement(expr);
    }
    
    // ==================== 表达式解析 ====================
    
    /// <summary>
    /// 解析表达式（入口）
    /// </summary>
    private Expression ParseExpression()
    {
        return ParseOrExpression();
    }
    
    /// <summary>
    /// 解析逻辑或表达式（优先级最低）
    /// </summary>
    private Expression ParseOrExpression()
    {
        var expr = ParseAndExpression();
        
        while (MatchKeyword("或"))
        {
            var op = Previous().Value;
            var right = ParseAndExpression();
            expr = new BinaryExpression(expr, op, right);
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析逻辑与表达式
    /// </summary>
    private Expression ParseAndExpression()
    {
        var expr = ParseEqualityExpression();
        
        while (MatchKeyword("且"))
        {
            var op = Previous().Value;
            var right = ParseEqualityExpression();
            expr = new BinaryExpression(expr, op, right);
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析相等比较表达式
    /// </summary>
    private Expression ParseEqualityExpression()
    {
        var expr = ParseComparisonExpression();
        
        while (MatchKeyword("同", "不同"))
        {
            var op = Previous().Value;
            var right = ParseComparisonExpression();
            expr = new BinaryExpression(expr, op, right);
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析比较表达式
    /// </summary>
    private Expression ParseComparisonExpression()
    {
        var expr = ParseAdditiveExpression();
        
        // 处理比较运算符：》《 不》不《，以及汉字形式：大于、小于
        // 注意："不大于"、"不小于"通过"不"+"大于/小于"组合实现
        while (Match(TokenType.ComparisonOperator) || 
               MatchKeyword("大于", "小于") ||
               MatchPunctuation("》", "《", "不》", "不《"))
        {
            var op = Previous().Value;
            var right = ParseAdditiveExpression();
            expr = new BinaryExpression(expr, op, right);
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析加减表达式
    /// </summary>
    private Expression ParseAdditiveExpression()
    {
        var expr = ParseMultiplicativeExpression();
        
        while (Check(TokenType.Operator) && 
               (Peek().Value == "+" || Peek().Value == "-"))
        {
            Advance();
            var op = Previous().Value;
            var right = ParseMultiplicativeExpression();
            expr = new BinaryExpression(expr, op, right);
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析乘除表达式
    /// </summary>
    private Expression ParseMultiplicativeExpression()
    {
        var expr = ParseUnaryExpression();
        
        while (Check(TokenType.Operator) && 
               (Peek().Value == "*" || Peek().Value == "÷" || 
                Peek().Value == "/" || Peek().Value == "%"))
        {
            Advance();
            var op = Previous().Value;
            var right = ParseUnaryExpression();
            expr = new BinaryExpression(expr, op, right);
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析一元表达式
    /// </summary>
    private Expression ParseUnaryExpression()
    {
        // 前缀运算符：++甲, --甲, 不 标记, +正号, -负号
        if (Match(TokenType.Operator) || MatchKeyword("不"))
        {
            var op = Previous().Value;
            var expr = ParseUnaryExpression();
            return new UnaryExpression(op, expr, true);
        }
        
        return ParsePostfixExpression();
    }
    
    /// <summary>
    /// 解析后缀表达式（属性访问、数组访问、函数调用、后缀++/--）
    /// </summary>
    private Expression ParsePostfixExpression()
    {
        var expr = ParsePrimaryExpression();
        
        while (true)
        {
            // 属性访问：甲的乙 或 甲·乙
            if (MatchKeyword("的"))
            {
                // 属性名可以是Identifier或TypeKeyword（如"文字"、"长"等）
                Token memberToken;
                if (Check(TokenType.Identifier))
                {
                    memberToken = Advance();
                }
                else if (Check(TokenType.TypeKeyword))
                {
                    memberToken = Advance();
                }
                else
                {
                    throw Error(Peek(), "期望属性名");
                }
                expr = new MemberAccessExpression(expr, memberToken.Value);
            }
            // 属性访问（间隔号形式）：甲·乙
            else if (MatchPunctuation("·"))
            {
                // 属性名可以是Identifier或TypeKeyword
                Token memberToken;
                if (Check(TokenType.Identifier))
                {
                    memberToken = Advance();
                }
                else if (Check(TokenType.TypeKeyword))
                {
                    memberToken = Advance();
                }
                else
                {
                    throw Error(Peek(), "期望属性名");
                }
                expr = new MemberAccessExpression(expr, memberToken.Value);
            }
            // 数组访问：甲【0】
            else if (MatchPunctuation("【"))
            {
                var index = ParseExpression();
                Consume(TokenType.Punctuation, "期望'】'");
                expr = new ArrayAccessExpression(expr, index);
            }
            // 函数调用：输出（"你好"）
            else if (MatchLeftParen())
            {
                var args = new List<Expression>();
                
                if (!IsRightParen())
                {
                    do
                    {
                        args.Add(ParseExpression());
                    } while (MatchPunctuation("，", ","));
                }
                
                ConsumeRightParen();
                
                // 如果expr是标识符，转换为函数调用
                if (expr is IdentifierExpression id)
                {
                    expr = new FunctionCallExpression(id.Name, args);
                }
                else
                {
                    throw Error(Peek(), "只能调用函数名");
                }
            }
            // 后缀++/--
            else if (Check(TokenType.Operator) && 
                     (Peek().Value == "++" || Peek().Value == "--"))
            {
                Advance();
                var op = Previous().Value;
                expr = new UnaryExpression(op, expr, false);
            }
            else
            {
                break;
            }
        }
        
        return expr;
    }
    
    /// <summary>
    /// 解析基本表达式（字面量、标识符、括号）
    /// </summary>
    private Expression ParsePrimaryExpression()
    {
        // 整数
        if (Match(TokenType.IntegerLiteral))
        {
            return new IntegerLiteral(int.Parse(Previous().Value));
        }
        
        // 实数
        if (Match(TokenType.DoubleLiteral))
        {
            return new DoubleLiteral(double.Parse(Previous().Value));
        }
        
        // 字符串
        if (Match(TokenType.StringLiteral))
        {
            return new StringLiteral(Previous().Value);
        }
        
        // 布尔
        if (Match(TokenType.BooleanLiteral))
        {
            return new BooleanLiteral(Previous().Value == "真真");
        }
        
        // 标识符（支持连续的Identifier+Keyword组合，如"加法"）
        if (Match(TokenType.Identifier))
        {
            var nameParts = new List<string> { Previous().Value };
            
            // 如果下一个是Keyword且再下一个是左括号，合并为函数名
            while (!IsAtEnd() && (Check(TokenType.Keyword) || Check(TokenType.TypeKeyword)))
            {
                // 向前看：是否是函数调用模式（如 "加法（"）
                if (_current + 1 < _tokens.Count && 
                    (_tokens[_current + 1].Type == TokenType.Punctuation) &&
                    (_tokens[_current + 1].Value == "（" || _tokens[_current + 1].Value == "("))
                {
                    nameParts.Add(Advance().Value);
                }
                else
                {
                    break;
                }
            }
            
            return new IdentifierExpression(string.Join("", nameParts));
        }
        
        // 特殊关键字作为变量名（如循环中的"几"）
        if (CheckValue("几"))
        {
            Advance();
            return new IdentifierExpression("几");
        }
        
        // 数组字面量：【1, 2, 3】
        if (MatchPunctuation("【"))
        {
            var elements = new List<Expression>();
            
            if (!Check(TokenType.Punctuation) || Peek().Value != "】")
            {
                do
                {
                    elements.Add(ParseExpression());
                } while (MatchPunctuation("，", ","));
            }
            
            Consume(TokenType.Punctuation, "期望'】'");
            return new ArrayLiteral(elements);
        }
        
        // 括号表达式：(expr)
        if (MatchLeftParen())
        {
            var expr = ParseExpression();
            ConsumeRightParen();
            return expr;
        }
        
        throw Error(Peek(), $"意外的token: {Peek().Value}");
    }
    
    /// <summary>
    /// 匹配左括号（支持半角和全角）
    /// </summary>
    private bool MatchLeftParen()
    {
        if (Check(TokenType.Punctuation))
        {
            var value = Peek().Value;
            if (value == "(" || value == "（")
            {
                Advance();
                return true;
            }
        }
        return false;
    }
    
    /// <summary>
    /// 检查右括号（支持半角和全角）
    /// </summary>
    private bool IsRightParen()
    {
        if (Check(TokenType.Punctuation))
        {
            var value = Peek().Value;
            return value == ")" || value == "）";
        }
        return false;
    }
    
    /// <summary>
    /// 消费右括号（支持半角和全角）
    /// </summary>
    private Token ConsumeRightParen(string message = "期望'）'或')'")
    {
        if (IsRightParen())
        {
            return Advance();
        }
        throw Error(Peek(), message);
    }
    
    // ==================== 类与对象解析 ====================
    
    /// <summary>
    /// 解析类定义：类名 是 类，含{ 属性... 方法... }
    /// </summary>
    private ClassDeclaration ParseClassDeclaration()
    {
        var className = Consume(TokenType.Identifier, "期望类名").Value;
        ConsumeKeyword("是", "期望'是'");
        ConsumeKeyword("类", "期望'类'");
        MatchPunctuation("，", ","); // 可选的逗号
        ConsumeKeyword("含", "期望'含'");
        
        var fields = new List<Field>();
        var methods = new List<ClassMethod>();
        
        // 单字段类：车 是 类，含 整型 价格。
        if (Check(TokenType.TypeKeyword))
        {
            var fieldType = Advance().Value;
            var fieldName = Consume(TokenType.Identifier, "期望字段名").Value;
            
            Expression? defaultValue = null;
            if (MatchKeyword("是"))
            {
                defaultValue = ParseExpression();
            }
            
            fields.Add(new Field(fieldType, fieldName, defaultValue));
            ConsumePeriod();
            
            return new ClassDeclaration(className, fields, methods);
        }
        
        // 多字段/方法类：车 是 类，含{ ... }
        Consume(TokenType.Punctuation, "期望'{'");
        
        while (!Check(TokenType.Punctuation) || Peek().Value != "}")
        {
            if (IsAtEnd())
            {
                throw Error(Peek(), "类定义未闭合，期望'}'");
            }
            
            // 跳过注释
            while (Match(TokenType.Comment)) { }
            
            // 检查是否是方法定义（以"求"或参数列表开头）
            if (IsMethodDeclaration())
            {
                methods.Add(ParseMethod());
            }
            // 否则是字段定义
            else if (Check(TokenType.TypeKeyword))
            {
                var fieldType = Advance().Value;
                var fieldName = Consume(TokenType.Identifier, "期望字段名").Value;
                
                Expression? defaultValue = null;
                if (MatchKeyword("是"))
                {
                    defaultValue = ParseExpression();
                }
                
                fields.Add(new Field(fieldType, fieldName, defaultValue));
                ConsumePeriod();
            }
            else
            {
                throw Error(Peek(), $"类定义中期望字段或方法，得到: {Peek().Value}");
            }
        }
        
        Consume(TokenType.Punctuation, "期望'}'");
        
        return new ClassDeclaration(className, fields, methods);
    }
    
    /// <summary>
    /// 判断是否是方法定义（与函数定义类似）
    /// </summary>
    private bool IsMethodDeclaration()
    {
        // 方法定义模式：
        // 1. 求 法 名字
        // 2. 类型 参数名 求 法 名字
        // 3. 类型 参数名，类型 参数名 求 法 名字
        
        int lookahead = 0;
        
        // 跳过参数列表
        while (_current + lookahead < _tokens.Count)
        {
            var token = _tokens[_current + lookahead];
            
            if (token.Value == "求")
            {
                return true;
            }
            
            // 如果遇到非参数相关的token，说明不是方法
            if (token.Type != TokenType.TypeKeyword && 
                token.Type != TokenType.Identifier && 
                token.Value != "，" && 
                token.Value != ",")
            {
                return false;
            }
            
            lookahead++;
            
            // 避免过度前瞻
            if (lookahead > 20)
            {
                return false;
            }
        }
        
        return false;
    }
    
    /// <summary>
    /// 解析类方法（成员函数）
    /// </summary>
    private ClassMethod ParseMethod()
    {
        // 与ParseFunctionDeclaration类似，但返回ClassMethod
        var parameters = new List<Parameter>();
        
        // 解析参数列表
        while (Check(TokenType.TypeKeyword))
        {
            var paramType = Advance().Value;
            var paramName = Consume(TokenType.Identifier, "期望参数名").Value;
            parameters.Add(new Parameter(paramType, paramName));
            
            if (MatchPunctuation("，", ","))
            {
                continue;
            }
            else
            {
                break;
            }
        }
        
        // 跳过"求"
        ConsumeKeyword("求", "期望'求'");
        
        // 检查返回类型
        string? returnType = null;
        if (Check(TokenType.TypeKeyword))
        {
            returnType = Advance().Value;
            ConsumeKeyword("之", "期望'之'");
        }
        
        // 跳过"法"
        ConsumeKeyword("法", "期望'法'");
        
        // 函数名 - 使用ConsumeAnyAsIdentifier允许方法名包含关键字
        var methodName = ConsumeAnyAsIdentifier("期望方法名");
        
        // 函数体
        var body = ParseBlock();
        
        return new ClassMethod(returnType, methodName, parameters, body);
    }
    
    /// <summary>
    /// 解析对象创建：车 宝马 或 车 宝马，含{...} 或 车 宝马，含 价格 是 23
    /// </summary>
    private ObjectCreationStatement ParseObjectCreation()
    {
        var className = Consume(TokenType.Identifier, "期望类名").Value;
        var objectName = Consume(TokenType.Identifier, "期望对象名").Value;
        
        var initializers = new List<PropertyInitializer>();
        
        // 情况1：空对象 - 车 宝马。
        if (Check(TokenType.Punctuation) && Peek().Value == "。")
        {
            ConsumePeriod();
            return new ObjectCreationStatement(className, objectName, initializers);
        }
        
        // 情况2/3：有初始化 - 车 宝马，含...
        if (MatchPunctuation("，", ","))
        {
            ConsumeKeyword("含", "期望'含'");
            
            // 情况2：块语法 - 车 宝马，含{ 价格 是 23。品牌 是 "BMW"。}
            if (Check(TokenType.Punctuation) && Peek().Value == "{")
            {
                Advance(); // 消费'{'
                
                while (!Check(TokenType.Punctuation) || Peek().Value != "}")
                {
                    if (IsAtEnd())
                    {
                        throw Error(Peek(), "对象初始化未闭合，期望'}'");
                    }
                    
                    // 跳过注释
                    while (Match(TokenType.Comment)) { }
                    
                    // 解析属性初始化：属性名 是 值。
                    var propertyName = Consume(TokenType.Identifier, "期望属性名").Value;
                    ConsumeKeyword("是", "期望'是'");
                    var value = ParseExpression();
                    initializers.Add(new PropertyInitializer(propertyName, value));
                    ConsumePeriod();
                }
                
                Consume(TokenType.Punctuation, "期望'}'");
            }
            // 情况3：单属性 - 车 宝马，含 价格 是 23。
            else
            {
                var propertyName = Consume(TokenType.Identifier, "期望属性名").Value;
                ConsumeKeyword("是", "期望'是'");
                var value = ParseExpression();
                initializers.Add(new PropertyInitializer(propertyName, value));
                ConsumePeriod();
            }
        }
        else
        {
            ConsumePeriod();
        }
        
        return new ObjectCreationStatement(className, objectName, initializers);
    }
}

/// <summary>
/// 解析异常 - 携带CompileError对象以支持8段式错误提示
/// </summary>
public class ParseException : Exception
{
    /// <summary>
    /// 编译错误对象（如果使用新的错误系统）
    /// </summary>
    public CompileError? CompileError { get; }
    
    /// <summary>
    /// 是否使用新的错误系统
    /// </summary>
    public bool HasCompileError => CompileError != null;
    
    /// <summary>
    /// 旧版本构造函数（兼容性）
    /// </summary>
    public ParseException(string message) : base(message)
    {
        CompileError = null;
    }
    
    /// <summary>
    /// 新版本构造函数（支持8段式错误提示）
    /// </summary>
    public ParseException(CompileError error) : base(error.Title)
    {
        CompileError = error;
    }
}

